// Copyright 2014 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#ifndef MEDIA_FORMATS_COMMON_OFFSET_BYTE_QUEUE_H_
#define MEDIA_FORMATS_COMMON_OFFSET_BYTE_QUEUE_H_

#include <stdint.h>

#include "base/macros.h"
#include "media/base/byte_queue.h"
#include "media/base/media_export.h"

namespace media {

// A wrapper around a ByteQueue which maintains a notion of a
// monotonically-increasing offset. All buffer access is done by passing these
// offsets into this class, going some way towards preventing the proliferation
// of many different meanings of "offset", "head", etc.
class MEDIA_EXPORT OffsetByteQueue {
public:
    OffsetByteQueue();
    ~OffsetByteQueue();

    // These work like their underlying ByteQueue counterparts.
    void Reset();
    void Push(const uint8_t* buf, int size);
    void Peek(const uint8_t** buf, int* size);
    void Pop(int count);

    // Sets |buf| to point at the first buffered byte corresponding to |offset|,
    // and |size| to the number of bytes available starting from that offset.
    //
    // It is an error if the offset is before the current head. It's not an error
    // if the current offset is beyond tail(), but you will of course get back
    // a null |buf| and a |size| of zero.
    void PeekAt(int64_t offset, const uint8_t** buf, int* size);

    // Marks the bytes up to (but not including) |max_offset| as ready for
    // deletion. This is relatively inexpensive, but will not necessarily reduce
    // the resident buffer size right away (or ever).
    //
    // Returns true if the full range of bytes were successfully trimmed,
    // including the case where |max_offset| is less than the current head.
    // Returns false if |max_offset| > tail() (although all bytes currently
    // buffered are still cleared).
    bool Trim(int64_t max_offset);

    // The head and tail positions, in terms of the file's absolute offsets.
    // tail() is an exclusive bound.
    int64_t head() { return head_; }
    int64_t tail() { return head_ + size_; }

private:
    // Synchronize |buf_| and |size_| with |queue_|.
    void Sync();

    ByteQueue queue_;
    const uint8_t* buf_;
    int size_;
    int64_t head_;

    DISALLOW_COPY_AND_ASSIGN(OffsetByteQueue);
};

} // namespace media

#endif // MEDIA_FORMATS_COMMON_OFFSET_BYTE_QUEUE_H_
